/**
 * 应用性能优化配置
 * 定义应用性能优化的各项参数和策略
 */

const performanceConfig = {
  /**
   * 性能监控配置
   */
  monitor: {
    // 是否启用性能监控
    enabled: true,
    
    // 是否开启调试模式
    debug: process.env.NODE_ENV === 'development',
    
    // FPS监控配置
    fps: {
      enabled: true,
      interval: 1000, // 监控间隔（毫秒）
      warningThreshold: 30 // FPS警告阈值
    },
    
    // 内存监控配置
    memory: {
      enabled: true,
      interval: 5000, // 监控间隔（毫秒）
      warningThreshold: 100 // 内存警告阈值（MB）
    },
    
    // 网络监控配置
    network: {
      enabled: true,
      slowRequestThreshold: 3000, // 慢请求阈值（毫秒）
      recordFailedRequests: true, // 是否记录失败的请求
      maxRecords: 200 // 最大记录数
    },
    
    // 页面性能监控配置
    page: {
      enabled: true,
      maxRecordsPerPage: 50 // 每个页面最大记录数
    }
  },
  
  /**
   * 缓存配置
   */
  cache: {
    // 图片缓存配置
    image: {
      enabled: true,
      maxCacheSize: 50, // 最大缓存图片数量
      maxCacheAge: 7 * 24 * 60 * 60 * 1000, // 最大缓存时间（7天）
      preloadDistance: 3000 // 预加载距离（像素）
    },
    
    // 数据缓存配置
    data: {
      enabled: true,
      defaultCacheTime: 5 * 60 * 1000, // 默认缓存时间（5分钟）
      storageKeyPrefix: 'star_mate_cache_', // 存储键前缀
      maxStorageSize: 10 * 1024 * 1024 // 最大存储大小（10MB）
    }
  },
  
  /**
   * 资源优化配置
   */
  resources: {
    // 图片优化配置
    image: {
      enabled: true,
      quality: 0.85, // 图片压缩质量（0-1）
      maxWidth: 1280, // 最大宽度
      maxHeight: 1920, // 最大高度
      lazyLoad: true, // 是否启用懒加载
      placeholderColor: '#f5f5f5' // 占位符颜色
    },
    
    // 字体优化配置
    font: {
      enabled: true,
      subsetFonts: true, // 是否使用子集字体
      preloadCriticalFonts: true // 是否预加载关键字体
    },
    
    // 动画优化配置
    animation: {
      enabled: true,
      preferTransform: true, // 优先使用transform属性
      avoidLayoutChanges: true, // 避免布局变化
      useRequestAnimationFrame: true, // 使用requestAnimationFrame
      animationFrameBudget: 16 // 动画帧预算（毫秒，约60fps）
    }
  },
  
  /**
   * 渲染优化配置
   */
  rendering: {
    // 列表渲染优化
    list: {
      enabled: true,
      virtualList: true, // 是否启用虚拟列表
      virtualListThreshold: 50, // 启用虚拟列表的阈值
      pageSize: 20, // 分页加载每页数量
      itemHeight: 120, // 预估的列表项高度（像素）
      bufferSize: 3 // 缓冲区大小（屏幕高度的倍数）
    },
    
    // 组件优化配置
    components: {
      enabled: true,
      memoizeComplexComponents: true, // 是否缓存复杂组件
      dynamicImport: true, // 是否使用动态导入
      keepAliveExclude: [], // 不使用keep-alive的组件
      keepAliveMaxComponents: 10 // keep-alive最大缓存组件数
    },
    
    // 更新优化配置
    update: {
      enabled: true,
      debounceEvents: ['scroll', 'resize'], // 需要防抖的事件
      debounceDelay: 300, // 防抖延迟（毫秒）
      throttleEvents: ['touchmove', 'mousemove'], // 需要节流的事件
      throttleDelay: 16 // 节流延迟（毫秒）
    }
  },
  
  /**
   * 网络优化配置
   */
  network: {
    // 请求优化配置
    request: {
      enabled: true,
      timeout: 10000, // 请求超时时间（毫秒）
      retryCount: 2, // 请求失败重试次数
      retryDelay: 1000, // 重试延迟（毫秒）
      concurrentLimit: 5, // 并发请求限制
      cacheGetRequests: true // 是否缓存GET请求
    },
    
    // 数据预加载配置
    prefetch: {
      enabled: true,
      predictNextPage: true, // 是否预测并预加载下一页
      prefetchOnIdle: true, // 是否在空闲时预加载
      maxPrefetchRequests: 2 // 最大预加载请求数
    },
    
    // WebSocket优化配置
    websocket: {
      enabled: true,
      reconnectInterval: 3000, // 重连间隔（毫秒）
      maxReconnectAttempts: 5, // 最大重连次数
      pingInterval: 30000, // 心跳间隔（毫秒）
      messageQueueMaxSize: 100 // 消息队列最大大小
    }
  },
  
  /**
   * 存储优化配置
   */
  storage: {
    // 本地存储优化
    local: {
      enabled: true,
      compressData: true, // 是否压缩数据
      encryptSensitiveData: true, // 是否加密敏感数据
      clearExpiredData: true, // 是否清理过期数据
      clearInterval: 24 * 60 * 60 * 1000 // 清理间隔（毫秒）
    },
    
    // 临时文件优化
    temp: {
      enabled: true,
      autoCleanTempFiles: true, // 是否自动清理临时文件
      maxTempSize: 20 * 1024 * 1024, // 最大临时文件大小（20MB）
      cleanOnAppStart: true, // 应用启动时清理
      cleanOnAppClose: true // 应用关闭时清理
    }
  },
  
  /**
   * 错误处理和恢复配置
   */
  errorHandling: {
    // 错误监控配置
    monitoring: {
      enabled: true,
      trackJavaScriptErrors: true, // 是否跟踪JavaScript错误
      trackResourceErrors: true, // 是否跟踪资源错误
      trackPromiseRejections: true // 是否跟踪Promise拒绝
    },
    
    // 错误恢复配置
    recovery: {
      enabled: true,
      autoRecoverFromCrashes: true, // 是否自动从崩溃中恢复
      saveApplicationState: true, // 是否保存应用状态
      retryFailedOperations: true // 是否重试失败的操作
    },
    
    // 降级策略配置
    fallback: {
      enabled: true,
      useStaticContent: true, // 是否使用静态内容作为降级方案
      disableNonEssentialFeatures: true, // 是否禁用非必要功能
      notifyUser: true // 是否通知用户
    }
  },
  
  /**
   * 后台优化配置
   */
  background: {
    // 后台任务配置
    tasks: {
      enabled: true,
      limitBackgroundProcessing: true, // 是否限制后台处理
      pauseNonEssentialTasks: true, // 是否暂停非必要任务
      resumeTasksOnForeground: true // 是否在前台时恢复任务
    },
    
    // 电池优化配置
    battery: {
      enabled: true,
      reducePowerUsage: true, // 是否减少电量使用
      monitorBatteryStatus: true, // 是否监控电池状态
      adaptToLowPower: true // 是否适应低电量模式
    }
  },
  
  /**
   * 开发环境特定配置
   */
  development: {
    verboseLogging: true, // 是否启用详细日志
    showPerformanceIndicators: true, // 是否显示性能指标
    traceRendering: false, // 是否跟踪渲染
    recordLongTasks: true // 是否记录长任务
  },
  
  /**
   * 生产环境特定配置
   */
  production: {
    verboseLogging: false, // 是否启用详细日志
    showPerformanceIndicators: false, // 是否显示性能指标
    traceRendering: false, // 是否跟踪渲染
    recordLongTasks: true // 是否记录长任务
  }
};

// 根据环境获取配置
const getConfig = () => {
  const isDev = process.env.NODE_ENV === 'development';
  const baseConfig = { ...performanceConfig };
  
  // 合并环境特定配置
  if (isDev) {
    baseConfig.development = { ...baseConfig.development };
  } else {
    baseConfig.production = { ...baseConfig.production };
  }
  
  return baseConfig;
};

// 导出配置
export default getConfig();

// 导出性能优化策略
export const performanceStrategies = {
  /**
   * 获取列表渲染优化策略
   * @param {number} itemCount - 列表项数量
   * @returns {Object} 优化策略
   */
  getListRenderingStrategy(itemCount) {
    const config = getConfig();
    const strategy = { ...config.rendering.list };
    
    // 根据列表项数量动态调整策略
    if (itemCount > 1000) {
      strategy.virtualList = true;
      strategy.bufferSize = 2; // 减少缓冲区以节省内存
    } else if (itemCount > 200) {
      strategy.virtualList = true;
    } else if (itemCount > 50) {
      strategy.virtualList = strategy.virtualListThreshold <= itemCount;
    } else {
      strategy.virtualList = false; // 少量数据不需要虚拟列表
    }
    
    return strategy;
  },
  
  /**
   * 获取网络请求优化策略
   * @param {string} url - 请求URL
   * @param {string} method - 请求方法
   * @returns {Object} 优化策略
   */
  getNetworkRequestStrategy(url, method) {
    const config = getConfig();
    const strategy = { ...config.network.request };
    
    // 根据请求类型和URL动态调整策略
    if (method === 'GET') {
      strategy.cache = strategy.cacheGetRequests;
    } else {
      strategy.cache = false; // 非GET请求不缓存
    }
    
    // 对于重要的API，增加超时时间
    if (url.includes('/api/important')) {
      strategy.timeout = 15000;
      strategy.retryCount = 3;
    }
    
    return strategy;
  },
  
  /**
   * 获取图片加载优化策略
   * @param {Object} imageInfo - 图片信息
   * @returns {Object} 优化策略
   */
  getImageLoadingStrategy(imageInfo) {
    const config = getConfig();
    const strategy = { ...config.resources.image };
    
    // 根据图片大小和类型动态调整策略
    if (imageInfo && imageInfo.width && imageInfo.height) {
      // 对于小图，降低质量要求
      if (imageInfo.width < 300 && imageInfo.height < 300) {
        strategy.quality = 0.8;
      }
    }
    
    return strategy;
  },
  
  /**
   * 获取存储优化策略
   * @param {string} dataType - 数据类型
   * @param {number} dataSize - 数据大小
   * @returns {Object} 优化策略
   */
  getStorageStrategy(dataType, dataSize) {
    const config = getConfig();
    const strategy = { ...config.storage.local };
    
    // 根据数据类型和大小动态调整策略
    if (dataType === 'image' || dataType === 'file') {
      // 文件类数据需要压缩
      strategy.compressData = true;
    }
    
    if (dataType === 'sensitive') {
      // 敏感数据需要加密
      strategy.encryptSensitiveData = true;
    }
    
    // 对于大型数据，减少缓存时间
    if (dataSize && dataSize > 1024 * 1024) { // 大于1MB
      strategy.cacheTime = 10 * 60 * 1000; // 10分钟
    }
    
    return strategy;
  }
};

// 导出性能检测规则
export const performanceRules = {
  /**
   * 页面加载性能规则
   */
  pageLoad: {
    // 良好: 页面加载时间 < 1秒
    good: 1000,
    // 一般: 1秒 <= 页面加载时间 < 3秒
    normal: 3000,
    // 较差: 页面加载时间 >= 3秒
    poor: 3000
  },
  
  /**
   * 首次内容绘制规则
   */
  fcp: {
    good: 1000,
    normal: 2000,
    poor: 2000
  },
  
  /**
   * FPS规则
   */
  fps: {
    good: 50,
    normal: 30,
    poor: 30
  },
  
  /**
   * 网络请求响应时间规则
   */
  networkResponse: {
    good: 300,
    normal: 1000,
    poor: 1000
  },
  
  /**
   * 内存使用规则（MB）
   */
  memoryUsage: {
    good: 50,
    normal: 100,
    poor: 100
  },
  
  /**
   * 大型任务执行时间规则（毫秒）
   */
  longTask: {
    threshold: 50 // 超过50ms的任务被视为长任务
  },
  
  /**
   * 动画性能规则
   */
  animation: {
    frameBudget: 16.7, // 约60fps
    jankThreshold: 10 // 每100帧允许的丢帧数
  }
};

// 导出性能评分函数
export const performanceScorer = {
  /**
   * 计算页面加载性能得分
   * @param {number} loadTime - 加载时间（毫秒）
   * @returns {number} 0-100的得分
   */
  scorePageLoad(loadTime) {
    const rules = performanceRules.pageLoad;
    
    if (loadTime <= rules.good) {
      return 100;
    } else if (loadTime <= rules.normal) {
      // 线性递减：从100到60
      return 100 - ((loadTime - rules.good) / (rules.normal - rules.good)) * 40;
    } else {
      // 超过normal阈值，得分低于60
      // 最低得分为20分
      const score = 60 - Math.min(40, (loadTime - rules.normal) / 1000 * 10);
      return Math.max(20, score);
    }
  },
  
  /**
   * 计算FPS性能得分
   * @param {number} fps - 帧率
   * @returns {number} 0-100的得分
   */
  scoreFps(fps) {
    const rules = performanceRules.fps;
    
    if (fps >= rules.good) {
      return 100;
    } else if (fps >= rules.normal) {
      // 线性递减：从100到60
      return 100 - ((rules.good - fps) / (rules.good - rules.normal)) * 40;
    } else {
      // 低于normal阈值，得分低于60
      // 最低得分为20分
      const score = 60 - Math.min(40, (rules.normal - fps) / 5 * 10);
      return Math.max(20, score);
    }
  },
  
  /**
   * 计算网络性能得分
   * @param {number} responseTime - 响应时间（毫秒）
   * @returns {number} 0-100的得分
   */
  scoreNetwork(responseTime) {
    const rules = performanceRules.networkResponse;
    
    if (responseTime <= rules.good) {
      return 100;
    } else if (responseTime <= rules.normal) {
      // 线性递减：从100到60
      return 100 - ((responseTime - rules.good) / (rules.normal - rules.good)) * 40;
    } else {
      // 超过normal阈值，得分低于60
      // 最低得分为20分
      const score = 60 - Math.min(40, (responseTime - rules.normal) / 1000 * 10);
      return Math.max(20, score);
    }
  },
  
  /**
   * 计算综合性能得分
   * @param {Object} scores - 各项得分
   * @returns {number} 0-100的综合得分
   */
  scoreOverall(scores) {
    const weights = {
      pageLoad: 0.3,
      fps: 0.3,
      network: 0.2,
      memory: 0.2
    };
    
    let totalScore = 0;
    let totalWeight = 0;
    
    for (const [key, weight] of Object.entries(weights)) {
      if (scores[key] !== undefined) {
        totalScore += scores[key] * weight;
        totalWeight += weight;
      }
    }
    
    return totalWeight > 0 ? totalScore / totalWeight : 0;
  }
};